package com.hns.tool.pub;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import net.sf.json.util.JSONStringer;

import org.apache.commons.beanutils.BeanUtils;

/**
 * json转换工具
 * @author:yecb
 * @email:zhuangcaijin@126.com
 * @version Revision 2.0.0
 */
public class JsonUtil {
	/**
	 * 将json字符串转化为指定对象
	 * @param jsonString json字符串
	 * @param pojoCalss 对象的类
	 * @return 转化后的对象
	 * @author:yecb
	 * @email:zhuangcaijin@126.com
	 */
	public static Object getObjectFromJsonString(String jsonString,
			Class pojoCalss) {
		Object pojo;
		JSONObject jsonObject = JSONObject.fromObject(jsonString);
		pojo = JSONObject.toBean(jsonObject, pojoCalss);
		return pojo;
	}

	/**
	 * 将指定对象转化为json字符串
	 * @param javaObj 对象
	 * @return json字符串
	 * @author:yecb
	 * @email:zhuangcaijin@126.com
	 */
	public static String getJsonStringFromObject(Object javaObj) {
		JSONObject json;
		json = JSONObject.fromObject(javaObj);
		return json.toString();
	}

	/**
	 * JSON转换成MAP
	 * @param jsonString json字符串
	 * @return 转化后的map
	 * @author:yecb
	 * @email:zhuangcaijin@126.com
	 */
	@SuppressWarnings("unchecked")
	public static Map getMapFromJsonString(String jsonString) {
		JSONObject jsonObject = JSONObject.fromObject(jsonString);
		Iterator keyIter = jsonObject.keys();
		String key;
		Object value;
		Map valueMap = new HashMap();
		while (keyIter.hasNext()) {
			key = (String) keyIter.next();
			value = jsonObject.get(key);
			valueMap.put(key, value);
		}
		return valueMap;
	}

	/**
	 * Map转换成JSON
	 * @param map map对象
	 * @return 转化后的json字符串
	 * @author:yecb
	 * @email:zhuangcaijin@126.com
	 */
	public static String getJsonStringFromMap(Map map) {
		JSONObject json = JSONObject.fromObject(map);
		return json.toString();
	}

	/**
	 * 将json字符串转化为Object数组
	 * @param jsonString json字符串
	 * @return Object数组
	 * @author:yecb
	 * @email:zhuangcaijin@126.com
	 */
	public static Object[] getObjectArrayFromJsonString(String jsonString) {
		JSONArray jsonArray = JSONArray.fromObject(jsonString);
		return jsonArray.toArray();
	}

	/**
	 * 将list转化为Object数组
	 * @param list 
	 * @return Object数组
	 * @author:yecb
	 * @email:zhuangcaijin@126.com
	 */
	public static Object[] getObjectArrayFromList(List list) {
		JSONArray jsonArray = JSONArray.fromObject(list);
		return jsonArray.toArray();
	}

	/**
	 * JSONStringer应用
	 * @param m
	 * @return
	 * @author:yecb
	 * @email:zhuangcaijin@126.com
	 */
	public static String buildJsonString(Map m) {
		JSONStringer stringer = new JSONStringer();
		stringer.object();
		// for (Object key : m.keySet()) {
		// stringer.key((String) key)
		// .value((String)m.get(key));
		// }
		stringer.key("phone");
		// begin nesting a array
		stringer.array();
		stringer.value("13998098000");
		stringer.value("8765432");

		stringer.value("13998098000");
		stringer.value("8765432");
		// nestring object in array
		stringer.object();
		stringer.key("ppcall");
		stringer.value(53881);
		stringer.endObject();
		stringer.value("13990980980");
		// end nesting a array
		stringer.endArray();

		stringer.endObject();
		return stringer.toString();
	}

	/**
	 * console打印map的key
	 * @param map
	 * @author:yecb
	 * @email:zhuangcaijin@126.com
	 */
	public static void printMap(Map map) {
		for (Object key : map.keySet()) {
			System.out.println(key + ":" + map.get(key));
		}
	}


	/**
	 * 将List对象序列化为JSON文本
	 * @param list List对象
	 * @return JSON文本
	 * @author:yecb
	 * @email:zhuangcaijin@126.com
	 */
	public static <T> String toJSONString(List<T> list) {
		JSONArray jsonArray = JSONArray.fromObject(list);

		return jsonArray.toString();
	}

	/**
	 * 将对象序列化为JSON文本
	 * @param object 对象
	 * @return JSON文本
	 * @author:yecb
	 * @email:zhuangcaijin@126.com
	 */
	public static String toJSONString(Object object) {
		JSONArray jsonArray = JSONArray.fromObject(object);

		return jsonArray.toString();
	}

	/**
	 * 将JSON对象数组序列化为JSON文本
	 * @param jsonArray JSON对象数组
	 * @return JSON文本
	 * @author:yecb
	 * @email:zhuangcaijin@126.com
	 */
	public static String toJSONString(JSONArray jsonArray) {
		return jsonArray.toString();
	}

	/**
	 * 将JSON对象序列化为JSON文本
	 * @param jsonObject JSON对象
	 * @return JSON文本
	 * @author:yecb
	 * @email:zhuangcaijin@126.com
	 */
	public static String toJSONString(JSONObject jsonObject) {
		return jsonObject.toString();
	}

	/**
	 * 将对象转换为List对象
	 * @param object 对象
	 * @return List对象
	 * @author:yecb
	 * @email:zhuangcaijin@126.com
	 */
	public static List toArrayList(Object object) {
		List arrayList = new ArrayList();

		JSONArray jsonArray = JSONArray.fromObject(object);

		Iterator it = jsonArray.iterator();
		while (it.hasNext()) {
			JSONObject jsonObject = (JSONObject) it.next();

			Iterator keys = jsonObject.keys();
			while (keys.hasNext()) {
				Object key = keys.next();
				Object value = jsonObject.get(key);
				arrayList.add(value);
			}
		}

		return arrayList;
	}

	/**
	 * 将对象转换为Collection对象
	 * @param object 对象
	 * @return Collection对象
	 * @author:yecb
	 * @email:zhuangcaijin@126.com
	 */
	public static Collection toCollection(Object object) {
		JSONArray jsonArray = JSONArray.fromObject(object);

		return JSONArray.toCollection(jsonArray);
	}

	/**
	 * 将对象转换为JSON对象数组
	 * @param object 对象
	 * @return JSON对象数组
	 * @author:yecb
	 * @email:zhuangcaijin@126.com
	 */
	public static JSONArray toJSONArray(Object object) {
		return JSONArray.fromObject(object);
	}

	/**
	 * 将对象转换为JSON对象
	 * @param object 对象
	 * @return JSON对象
	 * @author:yecb
	 * @email:zhuangcaijin@126.com
	 */
	public static JSONObject toJSONObject(Object object) {
		return JSONObject.fromObject(object);
	}

	/**
	 * 将对象转换为HashMap
	 * @param object 对象
	 * @return 转化后的HashMap
	 * @author:yecb
	 * @email:zhuangcaijin@126.com
	 */
	public static HashMap toHashMap(Object object) {
		HashMap<String, Object> data = new HashMap<String, Object>();
		JSONObject jsonObject = JsonUtil.toJSONObject(object);
		Iterator it = jsonObject.keys();
		while (it.hasNext()) {
			String key = String.valueOf(it.next());
			Object value = jsonObject.get(key);
			data.put(key, value);
		}

		return data;
	}

	/**
	 * 将对象转换为List<Map<String,Object>>
	 * @param object 对象
	 * @return List<Map<String,Object>>
	 * @author:yecb
	 * @email:zhuangcaijin@126.com
	 */
	// 返回非实体类型(Map<String,Object>)的List
	public static List<Map<String, Object>> toList(Object object) {
		List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
		JSONArray jsonArray = JSONArray.fromObject(object);
		for (Object obj : jsonArray) {
			JSONObject jsonObject = (JSONObject) obj;
			Map<String, Object> map = new HashMap<String, Object>();
			Iterator it = jsonObject.keys();
			while (it.hasNext()) {
				String key = (String) it.next();
				Object value = jsonObject.get(key);
				map.put((String) key, value);
			}
			list.add(map);
		}
		return list;
	}

	/**
	 * 将JSON对象数组转换为传入类型的List
	 * @param jsonArray JSON对象数组
	 * @param objectClass 传入类型
	 * @return 传入类型的List
	 * @author:yecb
	 * @email:zhuangcaijin@126.com
	 */
	public static <T> List<T> toList(JSONArray jsonArray, Class<T> objectClass) {
		return JSONArray.toList(jsonArray, objectClass);
	}

	/**
	 * 将对象转换为传入类型的List
	 * @param object 对象
	 * @param objectClass 传入类型
	 * @return 传入类型的List
	 * @author:yecb
	 * @email:zhuangcaijin@126.com
	 */
	public static <T> List<T> toList(Object object, Class<T> objectClass) {
		JSONArray jsonArray = JSONArray.fromObject(object);

		return JSONArray.toList(jsonArray, objectClass);
	}

	/**
	 * 将JSON对象转换为传入类型的对象
	 * @param jsonObject JSON对象
	 * @param beanClass 传入类型
	 * @return 传入类型的对象
	 * @author:yecb
	 * @email:zhuangcaijin@126.com
	 */
	public static <T> T toBean(JSONObject jsonObject, Class<T> beanClass) {
		return (T) JSONObject.toBean(jsonObject, beanClass);
	}

	/**
	 * 将对象转换为传入类型的对象
	 * @param object 对象
	 * @param beanClass 传入类型
	 * @return 传入类型的对象
	 * @author:yecb
	 * @email:zhuangcaijin@126.com
	 */
	public static <T> T toBean(Object object, Class<T> beanClass) {
		JSONObject jsonObject = JSONObject.fromObject(object);

		return (T) JSONObject.toBean(jsonObject, beanClass);
	}

	/**
	 * 将JSON文本反序列化为主从关系的实体
	 * @param <T> 泛型T 代表主实体类型
	 * @param <D> 泛型D 代表从实体类型
	 * @param jsonString JSON文本
	 * @param mainClass 主实体类型
	 * @param detailName 从实体类在主实体类中的属性名称
	 * @param detailClass 从实体类型
	 * @return 转化后的主从关系的实体
	 * @author:yecb
	 * @email:zhuangcaijin@126.com
	 */
	public static <T, D> T toBean(String jsonString, Class<T> mainClass,
			String detailName, Class<D> detailClass) {
		JSONObject jsonObject = JSONObject.fromObject(jsonString);
		JSONArray jsonArray = (JSONArray) jsonObject.get(detailName);

		T mainEntity = JsonUtil.toBean(jsonObject, mainClass);
		List<D> detailList = JsonUtil.toList(jsonArray, detailClass);

		try {
			BeanUtils.setProperty(mainEntity, detailName, detailList);
		} catch (Exception ex) {
			throw new RuntimeException("主从关系JSON反序列化实体失败！");
		}

		return mainEntity;
	}

	/**
	 * 将JSON文本反序列化为主从关系的实体
	 * @param <T>泛型T 代表主实体类型
	 * @param <D1>泛型D1 代表从实体类型
	 * @param <D2>泛型D2 代表从实体类型
	 * @param jsonString JSON文本
	 * @param mainClass 主实体类型
	 * @param detailName1 从实体类在主实体类中的属性
	 * @param detailClass1 从实体类型
	 * @param detailName2 从实体类在主实体类中的属性
	 * @param detailClass2 从实体类型
	 * @return 转化后的主从关系的实体
	 * @author:yecb
	 * @email:zhuangcaijin@126.com
	 */
	public static <T, D1, D2> T toBean(String jsonString, Class<T> mainClass,
			String detailName1, Class<D1> detailClass1, String detailName2,
			Class<D2> detailClass2) {
		JSONObject jsonObject = JSONObject.fromObject(jsonString);
		JSONArray jsonArray1 = (JSONArray) jsonObject.get(detailName1);
		JSONArray jsonArray2 = (JSONArray) jsonObject.get(detailName2);

		T mainEntity = JsonUtil.toBean(jsonObject, mainClass);
		List<D1> detailList1 = JsonUtil.toList(jsonArray1, detailClass1);
		List<D2> detailList2 = JsonUtil.toList(jsonArray2, detailClass2);

		try {
			BeanUtils.setProperty(mainEntity, detailName1, detailList1);
			BeanUtils.setProperty(mainEntity, detailName2, detailList2);
		} catch (Exception ex) {
			throw new RuntimeException("主从关系JSON反序列化实体失败！");
		}

		return mainEntity;
	}

	/**
	 * 将JSON文本反序列化为主从关系的实体
	 * @param <T>泛型T 代表主实体类型
	 * @param <D1>泛型D1 代表从实体类型
	 * @param <D2>泛型D2 代表从实体类型
	 * @param jsonString JSON文本
	 * @param mainClass 主实体类型
	 * @param detailName1 从实体类在主实体类中的属性
	 * @param detailClass1 从实体类型
	 * @param detailName2 从实体类在主实体类中的属性
	 * @param detailClass2 从实体类型
	 * @param detailName3 从实体类在主实体类中的属性
	 * @param detailClass3 从实体类型
	 * @return 转化后的主从关系的实体
	 * @author:yecb
	 * @email:zhuangcaijin@126.com
	 */
	public static <T, D1, D2, D3> T toBean(String jsonString,
			Class<T> mainClass, String detailName1, Class<D1> detailClass1,
			String detailName2, Class<D2> detailClass2, String detailName3,
			Class<D3> detailClass3) {
		JSONObject jsonObject = JSONObject.fromObject(jsonString);
		JSONArray jsonArray1 = (JSONArray) jsonObject.get(detailName1);
		JSONArray jsonArray2 = (JSONArray) jsonObject.get(detailName2);
		JSONArray jsonArray3 = (JSONArray) jsonObject.get(detailName3);

		T mainEntity = JsonUtil.toBean(jsonObject, mainClass);
		List<D1> detailList1 = JsonUtil.toList(jsonArray1, detailClass1);
		List<D2> detailList2 = JsonUtil.toList(jsonArray2, detailClass2);
		List<D3> detailList3 = JsonUtil.toList(jsonArray3, detailClass3);

		try {
			BeanUtils.setProperty(mainEntity, detailName1, detailList1);
			BeanUtils.setProperty(mainEntity, detailName2, detailList2);
			BeanUtils.setProperty(mainEntity, detailName3, detailList3);
		} catch (Exception ex) {
			throw new RuntimeException("主从关系JSON反序列化实体失败！");
		}

		return mainEntity;
	}

	/**
	 * 将JSON文本反序列化为主从关系的实体
	 * @param <T>
	 *            主实体类型
	 * @param jsonString JSON文本
	 * @param mainClass 主实体类型
	 * @param detailClass 存放了多个从实体在主实体中属性名称和类型
	 * @return 转化后的主从关系的实体
	 * @author:yecb
	 * @email:zhuangcaijin@126.com
	 */
	public static <T> T toBean(String jsonString, Class<T> mainClass,
			HashMap<String, Class> detailClass) {
		JSONObject jsonObject = JSONObject.fromObject(jsonString);
		T mainEntity = JsonUtil.toBean(jsonObject, mainClass);
		for (Object key : detailClass.keySet()) {
			try {
				Class value = (Class) detailClass.get(key);
				BeanUtils.setProperty(mainEntity, key.toString(), value);
			} catch (Exception ex) {
				throw new RuntimeException("主从关系JSON反序列化实体失败！");
			}
		}
		return mainEntity;
	}

	public static void main(String[] args) {
		Map m = new HashMap() {
			{
				put("1", new String[] { "1", "2" });
				put("2", new String[] { "3", "4" });
				put("Flex", "Ok");
			}
		};
		System.out.println(getJsonStringFromMap(m));
		 String test="{'devId':'05920007','period':'1','interval':'15'}";
		 System.out.println(getMapFromJsonString(test));
		 System.out.println(new JSONStringer().object().key("JSON")
				.value("Hello, World!").key("Flex").value("OK").endObject()
				.toString());
	}
}
